/**
 * Project 类型定义
 * 表示一个完整的 Python 作品项目
 */

import { getProjectVersion } from '../utils/version';

export class Project {
  constructor(options = {}) {
    // 项目基本信息
    this.id = options.id || this.generateId();
    this.name = options.name || '新的作品';
    this.description = options.description || '';
    this.version = options.version || getProjectVersion();
    this.createdAt = options.createdAt || new Date();
    this.lastModified = options.lastModified || new Date();
    
    // 项目配置
    this.config = {
      pythonVersion: options.config?.pythonVersion || '3.8',
      entryPoint: options.config?.entryPoint || 'main.py',
      ...options.config
    };
    
    // 文件系统引用（不维护独立数据）
    this.fs = options.fs || null;
    
    // 当前激活的文件ID（项目级别的聚焦文件，可选）
    this.activeFileId = options.activeFileId || null;
    
    // 执行历史
    this.executionHistory = options.executionHistory || [];
    
    // 项目状态
    this.isRunning = false;
    this.isDirty = false; // 是否有未保存的更改
    
    // 文件最后保存时间记录
    this.fileLastSaved = options.fileLastSaved || {};
  }

  /**
   * 生成唯一ID
   */
  generateId() {
    return 'project_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
  }

  /**
   * 设置文件系统引用
   */
  setFileSystem(fs) {
    this.fs = fs;
  }

  /**
   * 设置当前激活的文件
   */
  setActiveFile(fileId) {
    if (fileId === null) {
      this.activeFileId = null;
      this.markDirty();
      return true;
    }
    
    if (!this.fs) {
      throw new Error('文件系统未设置');
    }
    
    const file = this.fs.getItem(fileId);
    if (!file) {
      throw new Error(`文件不存在: ${fileId}`);
    }
    
    this.activeFileId = fileId;
    this.markDirty();
    return true;
  }

  /**
   * 获取当前激活的文件
   */
  getActiveFile() {
    return this.activeFileId ? this.fs?.getItem(this.activeFileId) : null;
  }

  /**
   * 获取当前激活的文件ID
   */
  getActiveFileId() {
    return this.activeFileId;
  }

  /**
   * 获取文件信息（从fs获取）
   */
  getFile(fileId) {
    return this.fs ? this.fs.getItem(fileId) : null;
  }

  /**
   * 获取所有文件（从fs获取）
   */
  getAllFiles() {
    if (!this.fs) return [];
    // 返回所有文件，包括子文件夹中的文件
    return this.fs.getFiles().concat(this.fs.getDirectories());
  }

  /**
   * 获取Python文件（从fs获取）
   */
  getPythonFiles() {
    return this.getAllFiles().filter(file => file.name.endsWith('.py'));
  }


  /**
   * 更新文件内容（直接操作fs）
   * @deprecated 现在直接操作fs，不需要通过Project
   */
  async updateFileContent(fileId, content) {
    if (!this.fs) return false;
    
    const file = this.fs.getItem(fileId);
    if (file) {
      await this.fs.updateFile(fileId, content);
      this.markDirty();
      
      // 记录文件最后保存时间
      this.fileLastSaved[fileId] = new Date();
      
      return true;
    }
    return false;
  }

  /**
   * 删除文件（直接操作fs）
   */
  async removeFile(fileId) {
    if (!this.fs) return false;
    
    const file = this.fs.getItem(fileId);
    if (file) {
      await this.fs.deleteFile(fileId);
      if (this.currentFileId === fileId) {
        this.currentFileId = null;
      }
      this.markDirty();
      
      // 删除文件保存时间记录
      delete this.fileLastSaved[fileId];
      
      return true;
    }
    return false;
  }
  
  /**
   * 获取文件最后保存时间
   */
  getFileLastSaved(fileId) {
    // 如果有保存时间记录，返回保存时间
    if (this.fileLastSaved[fileId]) {
      return this.fileLastSaved[fileId];
    }
    
    // 如果没有保存时间记录，返回文件修改时间（创建时与创建时间一致）
    const file = this.fs?.getItem(fileId);
    if (file && file.modifiedAt) {
      return file.modifiedAt;
    }
    
    return null;
  }
  
  /**
   * 获取当前文件最后保存时间
   */
  getCurrentFileLastSaved() {
    if (!this.currentFileId) return null;
    return this.getFileLastSaved(this.currentFileId);
  }

  /**
   * 添加执行历史
   */
  addExecutionHistory(execution) {
    this.executionHistory.push({
      ...execution,
      timestamp: new Date()
    });
    
    // 保持最近50条记录
    if (this.executionHistory.length > 50) {
      this.executionHistory = this.executionHistory.slice(-50);
    }
    
    this.markDirty();
  }

  /**
   * 获取最近执行的代码
   */
  getLastExecutedCode() {
    if (this.executionHistory.length > 0) {
      return this.executionHistory[this.executionHistory.length - 1].code;
    }
    return null;
  }

  /**
   * 清空执行历史
   */
  clearExecutionHistory() {
    this.executionHistory = [];
    this.markDirty();
  }

  /**
   * 标记项目为已修改
   */
  markDirty() {
    this.isDirty = true;
    this.lastModified = new Date();
  }

  /**
   * 标记项目为已保存
   */
  markSaved() {
    this.isDirty = false;
  }

  /**
   * 更新项目信息
   */
  updateInfo(info) {
    if (info.name !== undefined) this.name = info.name;
    if (info.description !== undefined) this.description = info.description;
    if (info.config !== undefined) this.config = { ...this.config, ...info.config };
    this.markDirty();
  }

  /**
   * 序列化为JSON（不包含文件数据，文件数据在fs中）
   */
  toJSON() {
    return {
      id: this.id,
      name: this.name,
      description: this.description,
      version: this.version,
      createdAt: this.createdAt,
      lastModified: this.lastModified,
      config: this.config,
      activeFileId: this.activeFileId,
      executionHistory: this.executionHistory,
      isRunning: this.isRunning,
      isDirty: this.isDirty,
      fileLastSaved: this.fileLastSaved
    };
  }

  /**
   * 从JSON反序列化（不恢复文件数据，需要单独设置fs）
   */
  static fromJSON(json) {
    const project = new Project({
      id: json.id,
      name: json.name,
      description: json.description,
      version: json.version,
      createdAt: new Date(json.createdAt),
      lastModified: new Date(json.lastModified),
      config: json.config,
      activeFileId: json.activeFileId,
      executionHistory: json.executionHistory || [],
      fileLastSaved: json.fileLastSaved || {}
    });

    project.isRunning = json.isRunning || false;
    project.isDirty = json.isDirty || false;

    return project;
  }

  /**
   * 导出项目为文件
   */
  async export(options = {}) {
    const { format = 'json' } = options;
    
    if (format === 'json') {
      // 导出项目元数据
      const projectData = this.toJSON();
      
      // 如果需要包含文件数据，从fs获取
      if (options.includeFiles && this.fs) {
        const files = this.getAllFiles();
        const fileData = await Promise.all(
          files.map(async (file) => ({
            id: file.id,
            name: file.name,
            path: file.path,
            content: await file.getContent('text'),
            type: file.type,
            size: file.size,
            createdAt: file.createdAt,
            lastModified: file.lastModified
          }))
        );
        projectData.files = fileData;
      }
      
      return JSON.stringify(projectData, null, 2);
    } else if (format === 'zip') {
      // 这里可以集成JSZip来导出为zip文件
      throw new Error('ZIP导出功能待实现');
    }
    
    throw new Error(`不支持的导出格式: ${format}`);
  }

  /**
   * 从文件导入项目
   */
  static async import(fileContent, options = {}) {
    const { format = 'json' } = options;
    
    if (format === 'json') {
      const json = JSON.parse(fileContent);
      const project = Project.fromJSON(json);
      
      // 如果有文件数据，需要单独处理（在projectManager中处理）
      if (json.files && json.files.length > 0) {
        project._importFiles = json.files; // 临时存储，供projectManager使用
      }
      
      return project;
    }
    
    throw new Error(`不支持的导入格式: ${format}`);
  }
}